<html>
	<head>
		<meta charset="utf-8"></meta>
		<title>BList</title>
		<link href="./style.css" rel="stylesheet" type="text/css"/>
	</head>
	<body>
		<div class="class" name="BList">
			<h1>BList</h1>
			<p>继承自<a href="BThing.html">BThing</a></p>
			<p id="resume">BList是链表容器，每个元素使用独立内存块。彼此之间使链接方式连接，所以对于调整的效率会比较高。<a href="#desc">详细</a></p>
			<h2>public</h2>
			<table id="public">
				<tr><td align="right">class </td><td><a href="#iterator">iterator</a></td></tr>
				<tr><td align="right">class </td><td><a href="#const_iterator">const_iterator</a></td></tr>
			</table>
			<h2>public</h2>
			<table id="public">
				<tr><td align="right">inline </td><td><a href="#BList() :)">BList</a>() : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BList(int size) :)">BList</a>(int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BList(const T&, int size) :)">BList</a>(const T& v, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BList(const UT*, int size) :)">BList</a>(const UT* values, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BList(const T*, int size) :)">BList</a>(const T* values, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BList(const BList<UT>& other) :)">BList</a>(const BList<UT>& other) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BList(const BList& other) :)">BList</a>(const BList& other) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#~BList()">~BList</a>();</td></tr>
				<tr><td align="right">inline int </td><td><a href="#size() const">size</a>() const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#empty() const">empty</a>() const;</td></tr>
				<tr><td align="right">inline void </td><td><a href="#clear()">clear</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#resize(int)">resize</a>(int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#check(int) const">check</a>(int index) const;</td></tr>
				<tr><td align="right">inline void </td><td><a href="#set(int, const T&)">set</a>(int pos, const T& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#move(int, int)">move</a>(int index, int dest);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#move(const iterator&, const iterator&)">move</a>(const iterator& it, const iterator& dest);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#raise(UT&)">raise</a>(UT& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#lower(UT&)">lower</a>(UT& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#swap(int, int)">swap</a>(int indexA, int indexB);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#swap(iterator&, iterator&)">swap</a>(iterator& itA, iterator& itB);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#swap(const iterator&, const iterator&)">swap</a>(const iterator& itA, const iterator& itB);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#sort(int)">sort</a>(int dir = 1);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#replace(const T&, const T&)">replace</a>(const T& oldValue, const T& newValue);</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#find(const UT&)">find</a>(const UT& value);</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#find(const UT&) const">find</a>(const UT& value) const;</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#rfind(const UT&)">rfind</a>(const UT& value);</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#rfind(const UT&) const">rfind</a>(const UT& value) const;</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#find_min()">find_min</a>();</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#find_min() const">find_min</a>() const;</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#find_max()">find_max</a>();</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#find_max() const">find_max</a>() const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#index(const UT&) const">index</a>(const UT& value) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#count(const UT&) const">count</a>(const UT& value) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#contain(const UT&) const">contain</a>(const UT& value) const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#first()">first</a>();</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#first() const">first</a>() const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#middle()">middle</a>();</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#middle() const">middle</a>() const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#last()">last</a>();</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#last() const">last</a>() const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#min()">min</a>();</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#min() const">min</a>() const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#max()">max</a>();</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#max() const">max</a>() const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#at(int)">at</a>(int index);</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#at(int) const">at</a>(int index) const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#def()">def</a>();</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#def() const">def</a>() const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#prepend()">prepend</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const T&)">prepend</a>(const T& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const UT*, int)">prepend</a>(const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const T*, int)">prepend</a>(const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const BList<UT>&)">prepend</a>(const BList<UT>& other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const BList&)">prepend</a>(const BList& other);</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#append()">append</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const T&,int)">append</a>(const T& value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const UT*, int)">append</a>(const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const T*, int)">append</a>(const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const BList<UT>&)">append</a>(const BList<UT>& other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const BList&)">append</a>(const BList& other);</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#insert(int)">insert</a>(int pos);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const T&,int)">insert</a>(int pos, const T& value, int count = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const UT*, int)">insert</a>(int pos, const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const T*, int)">insert</a>(int pos, const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const BList<UT>&)">insert</a>(int pos, const BList<UT>& other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const BList&)">insert</a>(int pos, const BList& other);</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#insert(const iterator&)">insert</a>(const iterator& it);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(const iterator&, const T&,int)">insert</a>(const iterator& it, const T& value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(const iterator&, const UT*, int)">insert</a>(const iterator& it, const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(const iterator&, const T*, int)">insert</a>(const iterator& it, const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(const iterator&, const BList<UT>&)">insert</a>(const iterator& it, const BList<UT>& other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(const iterator&, const BList&)">insert</a>(const iterator& it, const BList& other);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#remove(int,int)">remove</a>(int pos, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const UT&)">remove</a>(const UT& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const T&)">remove</a>(const T& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const UT*, int)">remove</a>(const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const T*, int)">remove</a>(const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const BList<UT>&)">remove</a>(const BList<UT>& other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const BList&)">remove</a>(const BList& other);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#removeAll(const UT&)">removeAll</a>(const UT& value);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#removeAll(const T&)">removeAll</a>(const T& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#removeAll(const BList<UT>&)">removeAll</a>(const BList<UT>& other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#removeAll(const BList&)">removeAll</a>(const BList& other);</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#push()">push</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#push(const T&)">push</a>(const T& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#pop()">pop</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#pop(T&)">pop</a>(T& value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#erase(iterator&)">erase</a>(iterator& it);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#erase(const iterator&)">erase</a>(const iterator& it);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#erase(iterator&, iterator&)">erase</a>(iterator& begin, iterator& end);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#erase(const iterator&, const iterator&)">erase</a>(const iterator& begin, const iterator& end);</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#begin()">begin</a>();</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#seek(int)">seek</a>(int index);</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#end()">end</a>();</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#begin() const">begin</a>() const;</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#seek(int) const">seek</a>(int index) const;</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#end() const">end</a>() const;</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#rbegin()">rbegin</a>();</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#rseek(int)">rseek</a>(int index);</td></tr>
				<tr><td align="right">inline iterator </td><td><a href="#rend()">rend</a>();</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#rbegin() const">rbegin</a>() const;</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#rseek(int) const">rseek</a>(int index) const;</td></tr>
				<tr><td align="right">inline const_iterator </td><td><a href="#rend() const">rend</a>() const;</td></tr>
				<tr><td align="right">inline const BList& </td><td><a href="#operator = (const BList<UT>&)">operator = </a>(const BList<UT>& other);</td></tr>
				<tr><td align="right">inline const BList& </td><td><a href="#operator = (const BList&)">operator = </a>(const BList& other);</td></tr>
				<tr><td align="right">inline BList& </td><td><a href="#operator << (const BList<UT>&)">operator &lt;&lt; </a>(const BList<UT>& other);</td></tr>
				<tr><td align="right">inline BList& </td><td><a href="#operator << (const BList&)">operator &lt;&lt; </a>(const BList& other);</td></tr>
				<tr><td align="right">inline BList& </td><td><a href="#operator << (const T&)">operator &lt;&lt; </a>(const T& value);</td></tr>
				<tr><td align="right">inline void </td><td><a href="#operator += (const UT&)">operator += </a>(const UT& value);</td></tr>
				<tr><td align="right">inline void </td><td><a href="#operator -= (const UT&)">operator -= </a>(const UT& value);</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#operator()(int)">operator</a>()(int index);</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#operator()(int) const">operator</a>()(int index) const;</td></tr>
				<tr><td align="right">inline T& </td><td><a href="#operator[](int)">operator[]</a>(int index);</td></tr>
				<tr><td align="right">inline const T& </td><td><a href="#operator[](int) const">operator[]</a>(int index) const;</td></tr>
			</table>
			<h2>public</h2>
			<table id="public">
				<tr><td align="right">int </td><td><a href="#_size;()">_size;</a></td></tr>
				<tr><td align="right">Node* </td><td><a href="#_first;()">_first;</a></td></tr>
				<tr><td align="right">Node* </td><td><a href="#_last;()">_last;</a></td></tr>
				<tr><td align="right">T </td><td><a href="#_def;()">_def;</a></td></tr>
			</table>
			<div id="desc">
				<h2>详细介绍：</h2>
				<p>BList是链表容器，每个元素使用独立内存块。彼此之间使链接方式连接，所以对于调整的效率会比较高。</p><p>虽然也可以使用索引进行取值，但索引取值是需要从头或从末尾进行迭代寻找的，所以索引的效率很低。建议使用迭代器进行访问，如下示例：<br/><pre>BList<BReal> rlist;
rlist << 123 << 456 << 789;
for(auto it = rlist.begin(); it != rlist.end(); it++)
{
	printf("%d : %lf.\n", it.index(), *it);
}</pre>
				</p><p>像其它容器一样，链表容器也有默认元素，是独立存在的，用于提高容错性。有时候也有特殊的用法。</p>
			</div>
			<h2 id="docs">成员文档：</h2>
			<div id="iterator">
				<h3>class iterator</h3>
				<p>这是BList元素访问迭代器，可对元素进行修改。</p>
			</div>
			<div id="const_iterator">
				<h3>class const_iterator</h3>
				<p>这是BList元素访问迭代器，不可对元素进行修改。</p>
			</div>
			<div id="BList() :)">
				<h3>inline BList() : _def();</h3>
				<p>构建一个空的链表，同时构造默认元素。</p>
			</div>
			<div id="BList(int size) :)">
				<h3>inline BList(int size) : _def();</h3>
				<p>构建一个链表，构造若干个元素，size指示元素个数。同时构造默认元素。</p>
			</div>
			<div id="BList(const T&, int size) :)">
				<h3>inline BList(const T&amp; v, int size) : _def();</h3>
				<p>构建一个链表，构造若干个元素，v用于构造元素，size指示元素个数。同时构造默认元素。</p>
			</div>
			<div id="BList(const UT*, int size) :)">
				<h3>inline BList(const UT* values, int size) : _def();</h3>
				<p>构建一个链表，构造若干个元素依次使用values的数据，size指示元素个数。同时构造默认元素。</p>
			</div>
			<div id="BList(const T*, int size) :)">
				<h3>inline BList(const T* values, int size) : _def();</h3>
				<p>构建一个链表，构造若干个元素依次使用values的数据，size指示元素个数。同时构造默认元素。</p>
			</div>
			<div id="BList(const BList<UT>& other) :)">
				<h3>inline BList(const BList&lt;UT&gt;&amp; other) : _def();</h3>
				<p>构建一个链表，构造若干个元素依次使用other的链表的数据。同时构造默认元素。</p>
			</div>
			<div id="BList(const BList& other) :)">
				<h3>inline BList(const BList&amp; other) : _def();</h3>
				<p>构建一个链表，构造若干个元素依次使用other的链表的数据。同时构造默认元素。</p>
			</div>
			<div id="~BList()">
				<h3>inline ~BList();</h3>
				<p>析构链表。</p>
			</div>
			<div id="size() const">
				<h3>inline int size() const;</h3>
			</div>
			<div id="empty() const">
				<h3>inline bool empty() const;</h3>
			</div>
			<div id="clear()">
				<h3>inline void clear();</h3>
				<p>清除所有元素。</p>
			</div>
			<div id="resize(int)">
				<h3>inline bool resize(int size);</h3>
				<p>调整元素个数为size。多的元素删除，不够的部分创建新的元素。</p>
			</div>
			<div id="check(int) const">
				<h3>inline bool check(int index) const;</h3>
			</div>
			<div id="set(int, const T&)">
				<h3>inline void set(int pos, const T&amp; value);</h3>
				<p>改变指定位置的元素数值。</p>
			</div>
			<div id="move(int, int)">
				<h3>inline bool move(int index, int dest);</h3>
				<p>移动index位置的元素到dest位置去，相当于取出元素再插入。</p>
			</div>
			<div id="move(const iterator&, const iterator&)">
				<h3>inline bool move(const iterator&amp; it, const iterator&amp; dest);</h3>
				<p>移动迭代器it表示的位置的元素到dest位置去，相当于取出元素再插入。</p>
			</div>
			<div id="raise(UT&)">
				<h3>inline bool raise(UT&amp; value);</h3>
				<p>找到第一个等于value的元素并将其移动到头部。</p>
			</div>
			<div id="lower(UT&)">
				<h3>inline bool lower(UT&amp; value);</h3>
				<p>找到第一个等于value的元素并将其移动到尾部。</p>
			</div>
			<div id="swap(int, int)">
				<h3>inline bool swap(int indexA, int indexB);</h3>
				<p>将indexA位置和indexB位置元素交换位置。</p>
			</div>
			<div id="swap(iterator&, iterator&)">
				<h3>inline bool swap(iterator&amp; itA, iterator&amp; itB);</h3>
				<p>将itA位置和itB位置元素交换位置。</p>
			</div>
			<div id="swap(const iterator&, const iterator&)">
				<h3>inline bool swap(const iterator&amp; itA, const iterator&amp; itB);</h3>
				<p>将itA位置和itB位置元素交换位置。</p>
			</div>
			<div id="sort(int)">
				<h3>inline bool sort(int dir = 1);</h3>
				<p>简单的排序功能，dir表示方向，当dir大于0表示从小到大，当dir小于0从大到小。若dir等于0则不排序。</p>
			</div>
			<div id="replace(const T&, const T&)">
				<h3>inline int replace(const T&amp; oldValue, const T&amp; newValue);</h3>
				<p>替换所有等于oldValue的元素为newValue。</p>
			</div>
			<div id="find(const UT&)">
				<h3>inline iterator find(const UT&amp; value);</h3>
				<p>寻找到等于value的元素，返回迭代器。</p>
			</div>
			<div id="find(const UT&) const">
				<h3>inline const_iterator find(const UT&amp; value) const;</h3>
			</div>
			<div id="rfind(const UT&)">
				<h3>inline iterator rfind(const UT&amp; value);</h3>
				<p>逆向寻找到等于value的元素，返回迭代器。</p>
			</div>
			<div id="rfind(const UT&) const">
				<h3>inline const_iterator rfind(const UT&amp; value) const;</h3>
			</div>
			<div id="find_min()">
				<h3>inline iterator find_min();</h3>
				<p>寻找所有元素中最小的一个，返回其迭代器。</p>
			</div>
			<div id="find_min() const">
				<h3>inline const_iterator find_min() const;</h3>
			</div>
			<div id="find_max()">
				<h3>inline iterator find_max();</h3>
				<p>寻找所有元素中最大的一个，返回其迭代器。</p>
			</div>
			<div id="find_max() const">
				<h3>inline const_iterator find_max() const;</h3>
			</div>
			<div id="index(const UT&) const">
				<h3>inline int index(const UT&amp; value) const;</h3>
			</div>
			<div id="count(const UT&) const">
				<h3>inline int count(const UT&amp; value) const;</h3>
			</div>
			<div id="contain(const UT&) const">
				<h3>inline bool contain(const UT&amp; value) const;</h3>
			</div>
			<div id="first()">
				<h3>inline T&amp; first();</h3>
				<p>取得第一个元素的引用。</p>
			</div>
			<div id="first() const">
				<h3>inline const T&amp; first() const;</h3>
			</div>
			<div id="middle()">
				<h3>inline T&amp; middle();</h3>
				<p>取得中间位置的元素的引用。</p>
			</div>
			<div id="middle() const">
				<h3>inline const T&amp; middle() const;</h3>
			</div>
			<div id="last()">
				<h3>inline T&amp; last();</h3>
				<p>取得最后一个元素的引用。</p>
			</div>
			<div id="last() const">
				<h3>inline const T&amp; last() const;</h3>
			</div>
			<div id="min()">
				<h3>inline T&amp; min();</h3>
				<p>取得所有元素中最小的元素的引用。</p>
			</div>
			<div id="min() const">
				<h3>inline const T&amp; min() const;</h3>
			</div>
			<div id="max()">
				<h3>inline T&amp; max();</h3>
				<p>取得所有元素中最大的元素的引用。</p>
			</div>
			<div id="max() const">
				<h3>inline const T&amp; max() const;</h3>
			</div>
			<div id="at(int)">
				<h3>inline T&amp; at(int index);</h3>
				<p>取得index位置的元素引用。</p>
			</div>
			<div id="at(int) const">
				<h3>inline const T&amp; at(int index) const;</h3>
			</div>
			<div id="def()">
				<h3>inline T&amp; def();</h3>
				<p>取得默认元素的引用。</p>
			</div>
			<div id="def() const">
				<h3>inline const T&amp; def() const;</h3>
			</div>
			<div id="prepend()">
				<h3>inline T&amp; prepend();</h3>
				<p>向链表头部添加一个元素，并返回其引用，新元素会被调用默认构造方法。</p>
			</div>
			<div id="prepend(const T&)">
				<h3>inline bool prepend(const T&amp; value);</h3>
				<p>向链表头部添加一个元素，新元素会被赋值为value。</p>
			</div>
			<div id="prepend(const UT*, int)">
				<h3>inline bool prepend(const UT* values, int size);</h3>
				<p>向链表头部添加若干个元素，使用指定的数据进行构造，元素个数是size。需要确保values的有效数据不少于size。</p>
			</div>
			<div id="prepend(const T*, int)">
				<h3>inline bool prepend(const T* values, int size);</h3>
				<p>向链表头部添加若干个元素，使用指定的数据进行构造，元素个数是size。需要确保values的有效数据不少于size。</p>
			</div>
			<div id="prepend(const BList<UT>&)">
				<h3>inline bool prepend(const BList&lt;UT&gt;&amp; other);</h3>
				<p>向链表头部添加若干个元素，使用other的元素进行构造，新元素个数与other的元素个数一样。</p>
			</div>
			<div id="prepend(const BList&)">
				<h3>inline bool prepend(const BList&amp; other);</h3>
				<p>向链表头部添加若干个元素，使用other的元素进行构造，新元素个数与other的元素个数一样。</p>
			</div>
			<div id="append()">
				<h3>inline T&amp; append();</h3>
				<p>向链表的尾部添加一个元素，并返回其引用。</p>
			</div>
			<div id="append(const T&,int)">
				<h3>inline bool append(const T&amp; value, int size = 1);</h3>
				<p>向链表的尾部添加若干个元素，各个元素都被赋予value，size指定新元素的个数 。</p>
			</div>
			<div id="append(const UT*, int)">
				<h3>inline bool append(const UT* values, int size);</h3>
				<p>向链表的尾部添加若干个元素，各个元素会被依次赋值为values的数据，size指定新元素的个数 。这里需要确保values中的有效数据个数不少于size，否则被导致内存访问错误。</p>
			</div>
			<div id="append(const T*, int)">
				<h3>inline bool append(const T* values, int size);</h3>
				<p>向链表的尾部添加若干个元素，各个元素会被依次赋值为values的数据，size指定新元素的个数 。这里需要确保values中的有效数据个数不少于size，否则被导致内存访问错误。</p>
			</div>
			<div id="append(const BList<UT>&)">
				<h3>inline bool append(const BList&lt;UT&gt;&amp; other);</h3>
				<p>向链表的尾部添加若干个元素，各个元素会被依次赋值为other的元素值。</p>
			</div>
			<div id="append(const BList&)">
				<h3>inline bool append(const BList&amp; other);</h3>
				<p>向链表的尾部添加若干个元素，各个元素会被依次赋值为other的元素值。</p>
			</div>
			<div id="insert(int)">
				<h3>inline T&amp; insert(int pos);</h3>
				<p>向链表的指定位置插入一个元素，并返回其引用。</p>
			</div>
			<div id="insert(int, const T&,int)">
				<h3>inline bool insert(int pos, const T&amp; value, int count = 1);</h3>
				<p>向链表的pos位置插入若干个元素，新元素都将被赋值为value，count指示新元素的数量。</p>
			</div>
			<div id="insert(int, const UT*, int)">
				<h3>inline bool insert(int pos, const UT* values, int size);</h3>
				<p>向链表的pos位置插入若干个元素，新元素都将被依次赋值为values[i]，size指示新元素的数量。注意values中需要确定有不少于size的数据。</p>
			</div>
			<div id="insert(int, const T*, int)">
				<h3>inline bool insert(int pos, const T* values, int size);</h3>
				<p>向链表的pos位置插入若干个元素，新元素都将被依次赋值为values[i]，size指示新元素的数量。注意values中需要确定有不少于size的数据。</p>
			</div>
			<div id="insert(int, const BList<UT>&)">
				<h3>inline bool insert(int pos, const BList&lt;UT&gt;&amp; other);</h3>
				<p>向链表的pos位置插入若干个元素，新元素都将被依次赋值为other[i]，新元素个数与other中的元素个数相同。</p>
			</div>
			<div id="insert(int, const BList&)">
				<h3>inline bool insert(int pos, const BList&amp; other);</h3>
				<p>I向链表的pos位置插入若干个元素，新元素都将被依次赋值为other[i]，新元素个数与other中的元素个数相同。</p>
			</div>
			<div id="insert(const iterator&)">
				<h3>inline T&amp; insert(const iterator&amp; it);</h3>
				<p>向链表的it表示的位置插入一个元素，并返回其引用。</p>
			</div>
			<div id="insert(const iterator&, const T&,int)">
				<h3>inline bool insert(const iterator&amp; it, const T&amp; value, int size = 1);</h3>
				<p>从链表的it表示的位置开始插入若干个元素，每个元素都被赋值为value，size指示新元素的数量。</p>
			</div>
			<div id="insert(const iterator&, const UT*, int)">
				<h3>inline bool insert(const iterator&amp; it, const UT* values, int size);</h3>
				<p>从链表的it表示的位置开始插入若干个元素，每个元素依次被赋值为values[i]，size指示新元素的数量。注意这里要确保values有不少于size的数据。</p>
			</div>
			<div id="insert(const iterator&, const T*, int)">
				<h3>inline bool insert(const iterator&amp; it, const T* values, int size);</h3>
				<p>从链表的it表示的位置开始插入若干个元素，每个元素依次被赋值为values[i]，size指示新元素的数量。注意这里要确保values有不少于size的数据。</p>
			</div>
			<div id="insert(const iterator&, const BList<UT>&)">
				<h3>inline bool insert(const iterator&amp; it, const BList&lt;UT&gt;&amp; other);</h3>
				<p>从链表的it表示的位置开始插入若干个元素，每个元素依次被赋值为other[i]，新元素的数量与other的元素数量一样。</p>
			</div>
			<div id="insert(const iterator&, const BList&)">
				<h3>inline bool insert(const iterator&amp; it, const BList&amp; other);</h3>
				<p>从链表的it表示的位置开始插入若干个元素，每个元素依次被赋值为other[i]，新元素的数量与other的元素数量一样。</p>
			</div>
			<div id="remove(int,int)">
				<h3>inline int remove(int pos, int size = 1);</h3>
				<p>从链表中删除元素，pos指示开始的位置，size表示删除的元素个数。</p>
			</div>
			<div id="remove(const UT&)">
				<h3>inline bool remove(const UT&amp; value);</h3>
				<p>从链表中删除第一个等于value的元素。</p>
			</div>
			<div id="remove(const T&)">
				<h3>inline bool remove(const T&amp; value);</h3>
				<p>从链表中删除第一个等于value的元素。</p>
			</div>
			<div id="remove(const UT*, int)">
				<h3>inline bool remove(const UT* values, int size);</h3>
				<p>从链表中删除所有包含在values中的元素，每个目标值只删除一次，values指示数据位置，size指示数据个数。</p>
			</div>
			<div id="remove(const T*, int)">
				<h3>inline bool remove(const T* values, int size);</h3>
				<p>从链表中删除所有包含在values中的元素，每个目标值只删除一次，values指示数据位置，size指示数据个数。</p>
			</div>
			<div id="remove(const BList<UT>&)">
				<h3>inline bool remove(const BList&lt;UT&gt;&amp; other);</h3>
				<p>从链表中删除所有包含在other中的元素，每个目标值只删除一次。</p>
			</div>
			<div id="remove(const BList&)">
				<h3>inline bool remove(const BList&amp; other);</h3>
				<p>从链表中删除所有包含在other中的元素，每个目标值只删除一次。</p>
			</div>
			<div id="removeAll(const UT&)">
				<h3>inline int removeAll(const UT&amp; value);</h3>
				<p>从链表中删除所有等于value的元素。</p>
			</div>
			<div id="removeAll(const T&)">
				<h3>inline int removeAll(const T&amp; value);</h3>
				<p>从链表中删除所有等于value的元素。</p>
			</div>
			<div id="removeAll(const BList<UT>&)">
				<h3>inline bool removeAll(const BList&lt;UT&gt;&amp; other);</h3>
				<p>从链表中删除每个等于other中数值的元素。</p>
			</div>
			<div id="removeAll(const BList&)">
				<h3>inline bool removeAll(const BList&amp; other);</h3>
				<p>从链表中删除每个等于other中数值的元素。</p>
			</div>
			<div id="push()">
				<h3>inline T&amp; push();</h3>
				<p>向链表尾部添加一个新元素，并返回其引用。功能与append()一致，此方法旨在提供栈的操作。</p>
			</div>
			<div id="push(const T&)">
				<h3>inline bool push(const T&amp; value);</h3>
				<p>向链表尾部添加一个新元素，并返回其引用。功能与append(value)一致，此方法旨在提供栈的操作。</p>
			</div>
			<div id="pop()">
				<h3>inline bool pop();</h3>
				<p>从链表发问删除一个元素，功能与remove(size() - 1)一样。此方法旨在提供栈的操作。</p>
			</div>
			<div id="pop(T&)">
				<h3>inline bool pop(T&amp; value);</h3>
				<p>从链表发问删除一个元素，功能与 value = last();remove(size() - 1)一样。此方法旨在提供栈的操作。</p>
			</div>
			<div id="erase(iterator&)">
				<h3>inline bool erase(iterator&amp; it);</h3>
				<p>从链表中it表示的位置删除一个元素，完成后迭代器依旧表示当前位置的元素。此方法效率最高，推荐使用。</p>
			</div>
			<div id="erase(const iterator&)">
				<h3>inline bool erase(const iterator&amp; it);</h3>
				<p>从链表中it表示的位置删除一个元素，完成后迭代器会是无效的。此方法效率最高，推荐使用。</p>
			</div>
			<div id="erase(iterator&, iterator&)">
				<h3>inline bool erase(iterator&amp; begin, iterator&amp; end);</h3>
				<p>从链表中删除指定区段的若干元素，begin指示开始处，end指示结束位置。操作完成后begin和end任然表示其位置。</p>
			</div>
			<div id="erase(const iterator&, const iterator&)">
				<h3>inline bool erase(const iterator&amp; begin, const iterator&amp; end);</h3>
				<p>从链表中删除指定区段的若干元素，begin指示开始处，end指示结束位置。操作完成后begin和end是无效的。</p>
			</div>
			<div id="begin()">
				<h3>inline iterator begin();</h3>
				<p>获得链表的起始迭代器，可用于修改元素。</p>
			</div>
			<div id="seek(int)">
				<h3>inline iterator seek(int index);</h3>
				<p>获取指定位置的迭代器，可用于修改元素。</p>
			</div>
			<div id="end()">
				<h3>inline iterator end();</h3>
				<p>获取链表的结束迭代器，此迭代器自身是无效的。</p>
			</div>
			<div id="begin() const">
				<h3>inline const_iterator begin() const;</h3>
			</div>
			<div id="seek(int) const">
				<h3>inline const_iterator seek(int index) const;</h3>
			</div>
			<div id="end() const">
				<h3>inline const_iterator end() const;</h3>
			</div>
			<div id="rbegin()">
				<h3>inline iterator rbegin();</h3>
				<p>获得此链表反向第一个迭代器，此值不同于end()，这是指示最后一个元素的位置。</p>
			</div>
			<div id="rseek(int)">
				<h3>inline iterator rseek(int index);</h3>
				<p>获得此链表的index位置的反向迭代器，可用于修改元素。</p>
			</div>
			<div id="rend()">
				<h3>inline iterator rend();</h3>
				<p>获得此链表反向结束位置迭代器，不可用于修改元素，因为其是指向-1位置的迭代器。</p>
			</div>
			<div id="rbegin() const">
				<h3>inline const_iterator rbegin() const;</h3>
			</div>
			<div id="rseek(int) const">
				<h3>inline const_iterator rseek(int index) const;</h3>
			</div>
			<div id="rend() const">
				<h3>inline const_iterator rend() const;</h3>
			</div>
			<div id="operator = (const BList<UT>&)">
				<h3>inline const BList&amp; operator = (const BList&lt;UT&gt;&amp; other);</h3>
				<p>清空身的所有元素，并添加other中的所有数据。操作完成后返回自身的常量引用。</p>
			</div>
			<div id="operator = (const BList&)">
				<h3>inline const BList&amp; operator = (const BList&amp; other);</h3>
				<p>清空身的所有元素，并添加other中的所有元素。操作完成后返回自身的常量引用。</p>
			</div>
			<div id="operator << (const BList<UT>&)">
				<h3>inline BList&amp; operator &lt;&lt; (const BList&lt;UT&gt;&amp; other);</h3>
				<p>向链表末尾添加other中的所有数据。操作完成后返回自身的引用。</p>
			</div>
			<div id="operator << (const BList&)">
				<h3>inline BList&amp; operator &lt;&lt; (const BList&amp; other);</h3>
				<p>向链表末尾添加other中的所有元素。操作完成后返回自身的引用。</p>
			</div>
			<div id="operator << (const T&)">
				<h3>inline BList&amp; operator &lt;&lt; (const T&amp; value);</h3>
				<p>向链表末尾添加一个元素，新元素赋值为value。操作完成后返回自身的引用。</p>
			</div>
			<div id="operator += (const UT&)">
				<h3>inline void operator += (const UT&amp; value);</h3>
				<p>向链表末尾添加一个元素，新元素赋值为value。</p>
			</div>
			<div id="operator -= (const UT&)">
				<h3>inline void operator -= (const UT&amp; value);</h3>
				<p>判断此链表的末尾的元素是否等于value，若等于则删除。</p>
			</div>
			<div id="operator()(int)">
				<h3>inline T&amp; operator()(int index);</h3>
				<p>获取链表中index位置的元素，此方法首先要判断index是否有效，若其无效则返回默认值。</p>
			</div>
			<div id="operator()(int) const">
				<h3>inline const T&amp; operator()(int index) const;</h3>
			</div>
			<div id="operator[](int)">
				<h3>inline T&amp; operator[](int index);</h3>
				<p>获取链表中index位置的元素，此方法不判断index是否有效，需要确保index有效，否则会访问错误。保留此bug用以暴露问题。</p>
			</div>
			<div id="operator[](int) const">
				<h3>inline const T&amp; operator[](int index) const;</h3>
			</div>
			<div id="_size;()">
				<h3>int _size;</h3>
			</div>
			<div id="_first;()">
				<h3>Node* _first;</h3>
			</div>
			<div id="_last;()">
				<h3>Node* _last;</h3>
			</div>
			<div id="_def;()">
				<h3>T _def;</h3>
			</div>
		</div>
	</body>
</html>